frontend/packages/webterminal-plugin/src/components/cloud-shell/__tests__/useCloudShellAvailable.spec.ts (1)

32-51: Tests will pass, but the rerender() call is unnecessary for these async assertions.

The initial renderHook() already triggers useEffect, which calls checkTerminalAvailable(). The await act(async () => {...}) wrapper flushes the microtask queue, allowing the mocked promise to settle. The rerender() inside doesn't contribute to waiting for the async operation.

A more idiomatic RTL pattern:

const { result } = renderHook(() => useCloudShellAvailable());
await act(async () => {
  // Let microtasks flush (promise resolution/rejection)
});
expect(result.current).toBe(false);

Or using waitFor for explicit state change detection:

import { renderHook, waitFor } from '@testing-library/react';
// ...
const { result } = renderHook(() => useCloudShellAvailable());
await waitFor(() => {
  expect(result.current).toBe(true);
});

Given this is a bulk migration PR, the current approach is functional and maintains consistency across files. Consider revisiting as a follow-up if you want tighter alignment with RTL best practices.

frontend/packages/console-shared/src/utils/__tests__/pod-ring-utils.spec.ts (1)

214-228: Async API call tests may not await completion.

These tests exercise code paths where checkPodEditAccess is invoked asynchronously (per the hook implementation in pod-ring-utils.ts). The assertions fire immediately after renderHook without using waitFor or act. They pass because the initial state (false) happens to match the expected final state, but they don't actually verify that the async operation completed.

Consider using waitFor to ensure the hook's effect completes:

♻️ Suggested pattern using waitFor

+import { renderHook, waitFor } from '@testing-library/react';
 ...
-  it('should return false when api call returns false for a resource', () => {
+  it('should return false when api call returns false for a resource', async () => {
     obj.kind = 'DeploymentConfig';
     const { result } = renderHook(() =>
       usePodScalingAccessStatus(obj, DeploymentConfigModel, [], true),
     );
+    await waitFor(() => {
+      expect(checkPodEditAccessMock).toHaveBeenCalled();
+    });
     expect(result.current).toBe(false);
   });

This ensures the mock was actually invoked and the async path was exercised, improving test reliability.

frontend/packages/topology/src/filters/__tests__/useSearchFilter.spec.ts (2)

34-41: Assertions inside renderHook callback is an anti-pattern.

The assertions are placed inside the renderHook callback rather than using result.current outside. While this works because the helper testUseSearchFilter invokes the hook synchronously, this pattern couples test assertions to the render phase and deviates from RTL's intended usage.

The idiomatic pattern would restructure tests to invoke testUseSearchFilter via renderHook and then assert on result.current:

♻️ Suggested refactor for idiomatic usage

 it('should handle null | undefined text', () => {
-  renderHook(() => {
-    expect(testUseSearchFilter(null, 'test')[0]).toBe(false);
-    expect(testUseSearchFilter(null, '')[0]).toBe(false);
-    expect(testUseSearchFilter(null, undefined)[0]).toBe(false);
-    expect(testUseSearchFilter(undefined, 'test')[0]).toBe(false);
-    expect(testUseSearchFilter(undefined, '')[0]).toBe(false);
-    expect(testUseSearchFilter(undefined, undefined)[0]).toBe(false);
-  });
+  expect(renderHook(() => testUseSearchFilter(null, 'test')).result.current[0]).toBe(false);
+  expect(renderHook(() => testUseSearchFilter(null, '')).result.current[0]).toBe(false);
+  expect(renderHook(() => testUseSearchFilter(null, undefined)).result.current[0]).toBe(false);
+  expect(renderHook(() => testUseSearchFilter(undefined, 'test')).result.current[0]).toBe(false);
+  expect(renderHook(() => testUseSearchFilter(undefined, '')).result.current[0]).toBe(false);
+  expect(renderHook(() => testUseSearchFilter(undefined, undefined)).result.current[0]).toBe(false);
 });

Alternatively, consider refactoring testUseSearchFilter to just set up mocks, and have each test call renderHook(() => useSearchFilter(...)) directly for cleaner separation.

---

44-92: Same pattern issue applies to remaining test cases.

All subsequent test cases (lines 44-92) follow the same anti-pattern of placing assertions inside the renderHook callback. Consider applying the same refactoring approach consistently across all tests in this file for maintainability.

frontend/packages/console-shared/src/hooks/__tests__/usePinnedResources.spec.ts (1)

63-83: Clean migration — consider removing vestigial async keywords.

The renderHook migration is correctly implemented. However, the test functions are marked async but don't contain any await statements. This is likely a remnant from the previous testHook usage. While harmless, removing the async keywords would improve clarity.

♻️ Optional: Remove unnecessary async

-it('should return default pins from extension if perspectives are not configured', async () => {
+it('should return default pins from extension if perspectives are not configured', () => {

Apply similarly to all test cases in this file.

frontend/packages/dev-console/src/components/add/hooks/__tests__/useAccessFilterExtensions.spec.ts (1)

27-35: Return hook result and assert via result.current

Inline assertions inside the render callback can miss updates and make timing brittle. Return the hook result and assert outside (use waitFor if updates are async).

♻️ Proposed refactor

-    renderHook(() => {
-      useAddActionsAccessReviewsSpy.mockReturnValue(mockAddAccessReviewResults);
-      const [filteredAddActionExtensions, loaded] = useAccessFilterExtensions(
-        namespace,
-        addActionExtensions,
-      );
-      expect(filteredAddActionExtensions.length).toEqual(0);
-      expect(loaded).toBe(false);
-    });
+    useAddActionsAccessReviewsSpy.mockReturnValue(mockAddAccessReviewResults);
+    const { result } = renderHook(() =>
+      useAccessFilterExtensions(namespace, addActionExtensions),
+    );
+    const [filteredAddActionExtensions, loaded] = result.current;
+    expect(filteredAddActionExtensions.length).toEqual(0);
+    expect(loaded).toBe(false);

-    renderHook(() => {
-      useAddActionsAccessReviewsSpy.mockReturnValue(mockAccessReviewResults);
-      const [filteredAddActionExtensions, loaded] = useAccessFilterExtensions(
-        namespace,
-        addActionExtensions,
-      );
-      expect(filteredAddActionExtensions.length).toEqual(accessAllowedResults.length);
-      expect(loaded).toBe(true);
-    });
+    useAddActionsAccessReviewsSpy.mockReturnValue(mockAccessReviewResults);
+    const { result } = renderHook(() =>
+      useAccessFilterExtensions(namespace, addActionExtensions),
+    );
+    const [filteredAddActionExtensions, loaded] = result.current;
+    expect(filteredAddActionExtensions.length).toEqual(accessAllowedResults.length);
+    expect(loaded).toBe(true);

Also applies to: 48-56